JavaScript WeakMap un WeakSet: Atmiņas ziņā efektīvu kolekciju pārvaldība

JavaScript piedāvā vairākas iebūvētas datu struktūras datu kolekciju pārvaldībai. Lai gan standarta Map un Set nodrošina spēcīgus rīkus, tie dažreiz var izraisīt atmiņas noplūdes, īpaši sarežģītās lietojumprogrammās. Šeit parādās WeakMap un WeakSet. Šīs specializētās kolekcijas piedāvā unikālu pieeju atmiņas pārvaldībai, ļaujot JavaScript atkritumu savācējam efektīvāk atgūt atmiņu.

Izpratne par problēmu: Spēcīgas atsauces

Pirms iedziļināties WeakMap un WeakSet, sapratīsim galveno problēmu: spēcīgas atsauces. JavaScript valodā, kad objekts tiek saglabāts kā atslēga Map vai kā vērtība Set, kolekcija uztur spēcīgu atsauci uz šo objektu. Tas nozīmē, ka, kamēr vien Map vai Set pastāv, atkritumu savācējs nevar atgūt atmiņu, ko aizņem objekts, pat ja objekts vairs netiek atsauces nekur citur jūsu kodā. Tas var izraisīt atmiņas noplūdes, īpaši, strādājot ar lielām vai ilgstošām kolekcijām.

Apsveriet šo piemēru:

            let myMap = new Map();
let key = { id: 1, name: "Example Object" };

myMap.set(key, "Some value");

// Even if 'key' is no longer used directly...
key = null;

// ... the Map still holds a reference to it.
console.log(myMap.size); // Output: 1

            

              
                Copy
              
            
          

Šajā scenārijā, pat pēc key iestatīšanas uz null, Map joprojām saglabā atsauci uz sākotnējo objektu. Atkritumu savācējs nevar atgūt atmiņu, ko izmanto šis objekts, jo Map to neļauj.

Iepazīstinām ar WeakMap un WeakSet: Vājas atsauces, lai glābtu

WeakMap un WeakSet risina šo problēmu, izmantojot vājas atsauces. Vāja atsauce ļauj atkritumu savācējam savākt objektu, ja uz to nav citu spēcīgu atsauču. Kad atslēga WeakMap vai vērtība WeakSet tiek atsauces tikai vāji, atkritumu savācējs var brīvi atgūt atmiņu. Kad objekts ir savākts, atbilstošais ieraksts tiek automātiski noņemts no WeakMap vai WeakSet.

WeakMap: Atslēgu un vērtību pāri ar vājām atslēgām

WeakMap ir atslēgu un vērtību pāru kolekcija, kur atslēgām jābūt objektiem. Atslēgas tiek turētas vāji, kas nozīmē, ka, ja atslēgas objekts vairs netiek atsauces citur, to var savākt atkritumos, un atbilstošais ieraksts WeakMap tiek noņemts. Vērtības, no otras puses, tiek turētas ar parastām (spēcīgām) atsaucēm.

Šeit ir pamata piemērs:

            let weakMap = new WeakMap();
let key = { id: 1, name: "WeakMap Key" };
let value = "Associated Data";

weakMap.set(key, value);

console.log(weakMap.get(key)); // Output: "Associated Data"

key = null;

// After garbage collection (which is not guaranteed to happen immediately)...
// weakMap.get(key) might return undefined.  This is implementation-dependent.
// We can't directly observe when an entry is removed from a WeakMap, which is by design.

            

              
                Copy
              
            
          

Galvenās atšķirības no Map:

• Atslēgām jābūt objektiem: Tikai objektus var izmantot kā atslēgas WeakMap. Primitīvas vērtības (virknes, skaitļi, Būla vērtības, simboli) nav atļautas. Tas ir tāpēc, ka primitīvas vērtības ir nemainīgas un tām nav nepieciešama atkritumu savākšana tādā pašā veidā kā objektiem.
• Nav iterācijas: Jūs nevarat iterēt pāri atslēgām, vērtībām vai ierakstiem WeakMap. Nav tādu metožu kā forEach, keys(), values() vai entries(). Tas ir tāpēc, ka šo metožu esamība prasītu, lai WeakMap uzturētu spēcīgu atsauci uz tās atslēgām, kas padarītu vāju atsauču mērķi bezjēdzīgu.
• Nav izmēra īpašības: WeakMap nav size īpašības. Izmēra noteikšanai būtu nepieciešams arī iterēt pāri atslēgām, kas nav atļauts.
• Ierobežotas metodes: WeakMap piedāvā tikai get(key), set(key, value), has(key) un delete(key).

WeakSet: Vāji turētu objektu kolekcija

WeakSet ir līdzīgs Set, bet tas ļauj saglabāt tikai objektus kā vērtības. Līdzīgi kā WeakMap, WeakSet tur šos objektus vāji. Ja objekts WeakSet vairs netiek atsauces spēcīgi citur, to var savākt atkritumos, un WeakSet automātiski noņem objektu.

Šeit ir vienkāršs piemērs:

            let weakSet = new WeakSet();
let obj1 = { id: 1, name: "Object 1" };
let obj2 = { id: 2, name: "Object 2" };

weakSet.add(obj1);
weakSet.add(obj2);

console.log(weakSet.has(obj1)); // Output: true

obj1 = null;

// After garbage collection (not guaranteed immediately)...
// weakSet.has(obj1) might return false.  This is implementation-dependent.
// We cannot directly observe when an element is removed from a WeakSet.

            

              
                Copy
              
            
          

Galvenās atšķirības no Set:

• Vērtībām jābūt objektiem: Tikai objektus var saglabāt WeakSet. Primitīvas vērtības nav atļautas.
• Nav iterācijas: Jūs nevarat iterēt pāri WeakSet. Nav forEach metodes vai citu līdzekļu, lai piekļūtu elementiem.
• Nav izmēra īpašības: WeakSet nav size īpašības.
• Ierobežotas metodes: WeakSet piedāvā tikai add(value), has(value) un delete(value).

Praktiski WeakMap un WeakSet lietošanas gadījumi

WeakMap un WeakSet ierobežojumi var padarīt tos mazāk daudzpusīgus nekā to spēcīgākie kolēģi. Tomēr to unikālās atmiņas pārvaldības iespējas padara tos nenovērtējamus noteiktos scenārijos.

1. DOM elementu metadati

Bieži sastopams lietošanas gadījums ir metadatu saistīšana ar DOM elementiem, nepiesārņojot DOM. Piemēram, jūs varat vēlēties saglabāt komponentu specifiskus datus, kas saistīti ar konkrētu HTML elementu. Izmantojot WeakMap, jūs varat nodrošināt, ka, kad DOM elements tiek noņemts no lapas, tiek savākti arī saistītie metadati, novēršot atmiņas noplūdes.

            let elementData = new WeakMap();

function initializeComponent(element) {
  let componentData = {
    // Component-specific data
    isActive: false,
    onClick: () => { console.log("Clicked!"); }
  };
  elementData.set(element, componentData);
}

let myElement = document.getElementById("myElement");
initializeComponent(myElement);

// Later, when the element is removed from the DOM:
// myElement.remove();

// The componentData associated with myElement will eventually be garbage collected
// when there are no other strong references to myElement.

            

              
                Copy
              
            
          

Šajā piemērā elementData saglabā metadatus, kas saistīti ar DOM elementiem. Kad myElement tiek noņemts no DOM, atkritumu savācējs var atgūt tā atmiņu, un atbilstošais ieraksts elementData tiek automātiski noņemts.

2. Dārgu operāciju rezultātu kešatmiņa

Jūs varat izmantot WeakMap, lai kešatmiņā saglabātu dārgu operāciju rezultātus, pamatojoties uz ievades objektiem. Ja ievades objekts vairs netiek izmantots, kešatmiņā saglabātais rezultāts tiek automātiski noņemts no WeakMap, atbrīvojot atmiņu.

            let cache = new WeakMap();

function expensiveOperation(input) {
  if (cache.has(input)) {
    console.log("Cache hit!");
    return cache.get(input);
  }

  console.log("Cache miss!");
  // Perform the expensive operation
  let result = input.id * 100;

  cache.set(input, result);
  return result;
}

let obj1 = { id: 5 };
let obj2 = { id: 10 };

console.log(expensiveOperation(obj1)); // Output: Cache miss!, 500
console.log(expensiveOperation(obj1)); // Output: Cache hit!, 500
console.log(expensiveOperation(obj2)); // Output: Cache miss!, 1000

obj1 = null;

// After garbage collection, the entry for obj1 will be removed from the cache.

            

              
                Copy
              
            
          

3. Privātie dati objektiem (WeakMap kā privāti lauki)

Pirms privāto klašu lauku ieviešanas JavaScript, WeakMap bija izplatīta tehnika, lai simulētu privātus datus objektos. Katrs objekts tiktu saistīts ar saviem privātiem datiem, kas saglabāti WeakMap. Tā kā dati ir pieejami tikai caur WeakMap un pašu objektu, tie ir efektīvi privāti.

            let _privateData = new WeakMap();

class MyClass {
  constructor(secret) {
    _privateData.set(this, { secret: secret });
  }

  getSecret() {
    return _privateData.get(this).secret;
  }
}

let instance = new MyClass("My Secret Value");
console.log(instance.getSecret()); // Output: My Secret Value

// Trying to access _privateData directly will not work.
// console.log(_privateData.get(instance).secret); // Error (if you somehow had access to _privateData)

// Even if the instance is garbage collected, the corresponding entry in _privateData will be removed.

            

              
                Copy
              
            
          

Lai gan privātie klašu lauki tagad ir vēlamākā pieeja, šī WeakMap modeļa izpratne joprojām ir vērtīga mantotajam kodam un JavaScript vēstures izpratnei.

4. Objekta dzīves cikla izsekošana

WeakSet var izmantot, lai izsekotu objektu dzīves ciklu. Jūs varat pievienot objektus WeakSet, kad tie tiek izveidoti, un pēc tam pārbaudīt, vai tie joprojām pastāv WeakSet. Kad objekts ir savākts, tas tiks automātiski noņemts no WeakSet.

            let trackedObjects = new WeakSet();

function trackObject(obj) {
  trackedObjects.add(obj);
}

function isObjectTracked(obj) {
  return trackedObjects.has(obj);
}

let myObject = { id: 123 };
trackObject(myObject);

console.log(isObjectTracked(myObject)); // Output: true

myObject = null;

// After garbage collection, isObjectTracked(myObject) might return false.

            

              
                Copy
              
            
          

Globāli apsvērumi un labākā prakse

Strādājot ar WeakMap un WeakSet, ņemiet vērā šo globālo labāko praksi:

• Izpratne par atkritumu savākšanu: Atkritumu savākšana nav deterministiska. Jūs nevarat precīzi paredzēt, kad objekts tiks savākts. Tāpēc jūs nevarat paļauties uz WeakMap vai WeakSet, lai nekavējoties noņemtu ierakstus, kad objekts vairs netiek atsauces.
• Izvairieties no pārmērīgas lietošanas: Lai gan WeakMap un WeakSet ir noderīgi atmiņas pārvaldībai, nepārmērīgi tos izmantojiet. Daudzos gadījumos standarta Map un Set ir pilnīgi adekvāti un piedāvā lielāku elastību. Izmantojiet WeakMap un WeakSet, kad jums konkrēti nepieciešamas vājas atsauces, lai izvairītos no atmiņas noplūdēm.
• Lietošanas gadījumi vājām atsaucēm: Padomājiet par objekta dzīves ilgumu, ko saglabājat kā atslēgu (WeakMap) vai vērtību (WeakSet). Ja objekts ir saistīts ar cita objekta dzīves ciklu, izmantojiet WeakMap vai WeakSet, lai izvairītos no atmiņas noplūdēm.
• Testēšanas izaicinājumi: Testēšanas kods, kas paļaujas uz atkritumu savākšanu, var būt izaicinošs. Jūs nevarat piespiest atkritumu savākšanu JavaScript. Apsveriet iespēju izmantot tādas metodes kā liela skaita objektu izveide un iznīcināšana, lai veicinātu atkritumu savākšanu testēšanas laikā.
• Polyfilling: Ja jums jāatbalsta vecākas pārlūkprogrammas, kas sākotnēji neatbalsta WeakMap un WeakSet, varat izmantot polyfill. Tomēr polyfill nevar pilnībā atkārtot vāju atsauču uzvedību, tāpēc rūpīgi pārbaudiet.

Piemērs: Internacionalizācijas (i18n) kešatmiņa

Iedomājieties scenāriju, kurā jūs veidojat tīmekļa lietojumprogrammu ar internacionalizācijas (i18n) atbalstu. Jūs varat vēlēties kešatmiņā saglabāt tulkotas virknes, pamatojoties uz lietotāja lokalizāciju. Jūs varat izmantot WeakMap, lai saglabātu kešatmiņu, kur atslēga ir lokalizācijas objekts un vērtība ir tulkotās virknes šai lokalizācijai. Kad lokalizācija vairs nav nepieciešama (piemēram, lietotājs pārslēdzas uz citu valodu un vecā lokalizācija vairs netiek atsauces), šīs lokalizācijas kešatmiņa tiks automātiski savākta.

            let i18nCache = new WeakMap();

function getTranslatedStrings(locale) {
  if (i18nCache.has(locale)) {
    return i18nCache.get(locale);
  }

  // Simulate fetching translated strings from a server.
  let translatedStrings = {
    "greeting": (locale.language === "fr") ? "Bonjour" : "Hello",
    "farewell": (locale.language === "fr") ? "Au revoir" : "Goodbye"
  };

  i18nCache.set(locale, translatedStrings);
  return translatedStrings;
}

let englishLocale = { language: "en", country: "US" };
let frenchLocale = { language: "fr", country: "FR" };

console.log(getTranslatedStrings(englishLocale).greeting); // Output: Hello
console.log(getTranslatedStrings(frenchLocale).greeting);  // Output: Bonjour

englishLocale = null;

// After garbage collection, the entry for englishLocale will be removed from the cache.

            

              
                Copy
              
            
          

Šī pieeja novērš i18n kešatmiņas neierobežotu pieaugumu un pārmērīgu atmiņas patēriņu, īpaši lietojumprogrammās, kas atbalsta lielu skaitu lokalizāciju.

Secinājums

WeakMap un WeakSet ir spēcīgi rīki atmiņas pārvaldībai JavaScript lietojumprogrammās. Izprotot to ierobežojumus un lietošanas gadījumus, jūs varat rakstīt efektīvāku un stabilāku kodu, kas izvairās no atmiņas noplūdēm. Lai gan tie var nebūt piemēroti katram scenārijam, tie ir būtiski situācijās, kad jums jāsaista dati ar objektiem, neļaujot šiem objektiem tikt savāktiem. Izmantojiet šīs kolekcijas, lai optimizētu savas JavaScript lietojumprogrammas un radītu labāku pieredzi saviem lietotājiem, neatkarīgi no tā, kur viņi atrodas pasaulē.